home *** CD-ROM | disk | FTP | other *** search
/ Language/OS - Multiplatform Resource Library / LANGUAGE OS.iso / oper_sys / emerald / emrldsys.lha / Kernel / KmdOps / snapshot.c < prev    next >
Encoding:
C/C++ Source or Header  |  1990-08-30  |  8.1 KB  |  315 lines
  1. /* COPYRIGHT  NOTICE :
  2.  * Copyright 1986 Eric Jul.  May not be used for any
  3.  * purpose without written permission from the author.
  4.  */
  5.  
  6. /* File:        snapshot.c      Eric Jul, 1986-05-03  */
  7.  
  8. /*
  9.  * $Header$
  10.  * INTERFACE:    See usage printout.
  11.  *
  12.  * FUNCTION:    sends snapshot requests to the kernel
  13.  *
  14.  * IMPORTS:    loads, see #include
  15.  *
  16.  * EXPORTS:    Nothing.
  17.  *
  18.  * DESIGN:    Send snapshot message to process and then
  19.  *              repeatedly receive and print data until stop snapshot
  20.  *              message arrives.
  21.  *
  22.  * $Log$
  23.  * 1983-06-08   Initial implementation, Eric Jul.
  24.  * 1985-03-04   Eric Jul
  25.  * 1986-05-03   Modified to work with 4.2bsd sockets.
  26.  */
  27.  
  28. #undef integer
  29. #include <sys/types.h>
  30. #include <sys/socket.h>
  31. #include <netinet/in.h>
  32. #include <stdio.h>
  33.  
  34. #define mSUCCESS(X) (((X) & 7) == 1)
  35.  
  36. typedef int KKStatus;
  37.  
  38. #define MAXMESSAGESIZE        1000
  39. #include "Kernel/h/emPorts.h"
  40. #include "Kernel/h/kmdDefs.h"
  41.  
  42. #include <netdb.h>
  43. #include <signal.h>
  44.  
  45. #define endcase break
  46.  
  47. char *snapshotname, *snapshotstring;
  48. int                  talkSock;
  49. int                  pid = 0;
  50. int                  prodTime = 1;
  51. int                  MType, MInt;
  52. char                 MString[5000];
  53. struct sockaddr_in   destSockDescr = {AF_INET};
  54.  
  55. /* Define signal handlers */
  56.  
  57. void PipeHandler(sig)
  58. int sig;
  59. {
  60.   printf("SIGPIPE>>> The connection to the process broke.\nTerminating.\n");
  61.   exit(sig);
  62. }
  63.  
  64. void TerminationHandler(sig)
  65. int sig;
  66. { 
  67.  
  68.     if (sig != 0) {
  69.     printf("Terminating snapshot due to signal %d.\n", sig);
  70.     } else {
  71.     printf("Snapshot done.\n");
  72.     }
  73.  
  74.     /* Important to tell kernel that we are bye, bye ... */
  75.     KMDSend(talkSock, KMDCLASTMSG, 0, "Done");
  76.     if (shutdown(talkSock, 1) < 0) {
  77.     perror("shutdown1");
  78.         close(talkSock);
  79.     exit(sig);
  80.     }
  81.     
  82.     while(mSUCCESS(KMDReceive(talkSock, &MType, &MInt, MString)));
  83.     close(talkSock);
  84.     exit(sig);
  85. };
  86.  
  87.  
  88. void Prodder()
  89. /* Prods the kernel by sending a SIGURG signal.
  90.    Exponential backoff.
  91.  */
  92. {
  93. /*    kill(pid, SIGURG); */
  94.     prodTime += prodTime;
  95.     alarm(prodTime);
  96. }
  97.  
  98.  
  99. main(argc, argv)
  100. int         argc;
  101. char        *argv[];
  102. {
  103.   int               OK;
  104.   char              snapbuf[500];
  105.   static int        i, EPLNN, SValue;
  106.   static int        pidGiven = 0, machineNameGiven = 0;
  107.   KKStatus          kstat;
  108.   char              myHostName[100];
  109.   struct hostent   *myHost;
  110.  
  111.     snapshotname = "Menu";           /* default */
  112.     snapshotstring = (char *) 0;
  113.     SValue = 0;                      /* default */
  114.     EPLNN = 8;                       /* default */
  115.     
  116.         if (argc == 2) 
  117.             if (!strcmp(argv[1], "usage")) {
  118.             printf("Usage: snapshot [-m <machine name>] [-N <LNN> | -X <hexLNN> | -P <pid>] [-n <snapname>] [-{d|h} <parameter value> | -S <string>\n");
  119.                 exit(0);
  120.             };
  121.  
  122.     /*
  123.      * Parse command line options
  124.      */
  125.     while (argc > 1 && argv[1][0] == '-') {
  126.         switch (argv[1][1]) {
  127.         case 'N':        /* Set logical node number */
  128.             if (argv[1][2] == '\0') {
  129.                 EPLNN = atoi(argv[2]);
  130.                 argc--;
  131.                 argv++;
  132.             } else
  133.                 EPLNN = atoi(&argv[1][2]);
  134.                         
  135.             printf("warning: -N ignored.\n");
  136.             break;
  137.         case 'X':        /* Set logical node number (hex) */
  138.                         if (argv[1][2] == '\0') {
  139.                                 sscanf(argv[2], "%x", &EPLNN);
  140.                                 argc--;
  141.                                 argv++;
  142.                         } else
  143.                                 sscanf(&argv[1][2], "%x", &EPLNN);
  144.             printf("warning: -X ignored.\n");
  145.             break;
  146.         case 'D':
  147.             KMDTest = 1;
  148.             break;
  149.         case 'd':
  150.             if (argv[1][2] == '\0') {
  151.                 SValue = atoi(argv[2]);
  152.                 argc--;
  153.                 argv++;
  154.             } else
  155.                 SValue = atoi(&argv[1][2]);
  156.             break;
  157.         case 'P':       /* Set pid, cancel LNN usage. */
  158.             if (argv[1][2] == '\0') {
  159.                 pid = atoi(argv[2]);
  160.                 argc--;
  161.                 argv++;
  162.             } else
  163.                 pid = atoi(&argv[1][2]);
  164.                         pidGiven = 1;
  165.             printf("warning: -P ignored.\n");
  166.             break;
  167.                 case 'h':
  168.                         if (argv[1][2] == '\0') {
  169.                                 sscanf(argv[2], "%x", &SValue);
  170.                                 argc--;
  171.                                 argv++;
  172.                         } else
  173.                                 sscanf(&argv[1][2], "%x", &SValue);
  174.                         break;
  175.                 case 'n':
  176.                         snapshotname = argv[2];
  177.                         argc--;
  178.                         argv++;
  179.                         break;
  180.                 case 'S':
  181.                         snapshotstring = argv[2];
  182.                         argc--;
  183.                         argv++;
  184.                         break;
  185.                 case 'M':
  186.                 case 'm':
  187.                         strcpy(myHostName, argv[2]);
  188.                         argc--;
  189.                         argv++;
  190.             machineNameGiven ++;
  191.                         break;
  192.                 default:
  193.                         printf("Warning: Unknown option: %c", argv[1][2]);
  194.                         break;
  195.  
  196.         }
  197.         argc--;
  198.         argv++;
  199.     }
  200.  
  201.     
  202.     /* Set termination handler. */
  203.     signal(SIGHUP, TerminationHandler);
  204.     signal(SIGQUIT, TerminationHandler);
  205.     signal(SIGINT, TerminationHandler);
  206.     signal(SIGBUS, TerminationHandler);
  207.     signal(SIGSEGV, TerminationHandler);
  208.     signal(SIGTERM, TerminationHandler);
  209.     signal(SIGPIPE, PipeHandler);
  210.     signal(SIGALRM, Prodder);
  211.     
  212.     talkSock = socket(AF_INET, SOCK_STREAM, 0, 0);
  213.     if (talkSock < 0) {
  214.                 perror("snapshot: socket");
  215.                 exit(1);
  216.     }
  217.  
  218.     if (! machineNameGiven) {
  219.     if (gethostname(myHostName, 100) < 0) {
  220.         perror("snapshot: gethostname");
  221.         exit(1);
  222.     }
  223.     }
  224.     myHost = gethostbyname(myHostName);
  225.     if (myHost == NULL) {
  226.             perror("snapshot: gethostbyname");
  227.             exit(1);
  228.     }
  229.  
  230.     bcopy(myHost->h_addr, &destSockDescr.sin_addr, myHost->h_length);
  231.  
  232.     {
  233.       char *emplanename;
  234.       int emPlane = 0;
  235.       int emPort = EMKERNELDEFAULTPORTNUMBER;
  236.       struct servent   *myService;
  237.       emplanename = (char *) getenv("EMPLANE");
  238.       if (emplanename != NULL) emPlane = atoi(emplanename);
  239. #ifdef DIKU
  240.       myService = getservbyname(EMKERNELSERVICEPORT, "tcp");
  241.       if(myService)
  242.     emPort = ntohs(myService->s_port);
  243. #endif
  244.       destSockDescr.sin_port = htons(emPort + emPlane*4 + 1);
  245.     }
  246.  
  247.     if (connect(talkSock, &destSockDescr, sizeof(destSockDescr)) == -1) {
  248.                 perror("snapshot: connect");
  249.                 exit(1);
  250.     }
  251.  
  252.  
  253.     if ( KMDTest )
  254.         printf("Connected to %d\n", ntohs(destSockDescr.sin_port));
  255.     
  256.     KMDReceive(talkSock, &MType, &MInt, MString);
  257.     printf("%s", MString);
  258.  
  259.     /* Start snapshot.*/
  260.     sprintf(snapbuf, "%s %s", snapshotname, snapshotstring);
  261.     kstat = KMDSend(talkSock, KMDCSNAPSHOT, SValue, snapbuf);
  262.  
  263.     if (! mSUCCESS( kstat ) ) {
  264.         printf("snapshot: Send start snapshot msg failure, kstat = 0x%08x\n",
  265.         kstat);
  266.         exit(1);
  267.     };
  268.     
  269.     printf("Calling %s on %s, param: %d (0x%02x)\n",
  270.         snapshotname, myHostName, SValue, SValue);
  271.     
  272.     fflush(stdout);
  273.     OK = 1;
  274.     while (OK==1) {
  275.         if(!mSUCCESS(kstat = KMDReceive(talkSock, &MType, &MInt, MString))){
  276.         printf("Premature snapshot termination\n");
  277.         perror("recv");
  278.             printf("Kernel status 0x%06x\n");
  279.         TerminationHandler(0);
  280.     };
  281.     
  282.         if ( KMDTest ){
  283.             printf("Msg from: %d, (%d, %d, %s)\n", talkSock,
  284.                 MType, MInt, MString),
  285.             fflush(stdout);
  286.     };
  287.         switch ( MType ) {
  288.         
  289.         case KMDCDATA:
  290.             printf("%s", MString);
  291.             fflush(stdout);
  292.         endcase;
  293.         
  294.         case KMDCERRMSG: /* Error message */
  295.             printf("snapshot: %s\n", MString);
  296.             fflush(stdout);
  297.             OK = 0;         /* quit */
  298.         endcase;
  299.         
  300.         case KMDCLASTMSG:
  301.             printf("%s", MString);
  302.             OK = 0;         /* quit. */
  303.         endcase;
  304.  
  305.         default:
  306.             printf("snapshot: Warning, bad msgtype: %d - ignored.\n", MType);
  307.         };
  308.     }
  309.     TerminationHandler(0);        
  310. }
  311.  
  312. /*  C O P Y R I G H T   N O T I C E :                                     */
  313. /* Copyright 1986 Eric Jul.  May not be used for any               */
  314. /* purpose without written permission from the author.              */
  315.